In [1]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.impute import SimpleImputer
from scipy.stats import zscore
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import confusion_matrix,accuracy_score
from sklearn.decomposition import PCA
from sklearn import metrics
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
In [2]:
veh= pd.read_csv("vehicle-1.csv") # Loading the dataset.
In [3]:
veh.shape # shape od the dataset.
Out[3]:
In [4]:
veh.head() # to get a general idea of data.
Out[4]:
In [5]:
veh.info() #Identifying datatype of each columns.
In [6]:
veh.describe()
Out[6]:
In [7]:
veh.isnull().values.any() # To check if there are null values.
Out[7]:
In [8]:
labelencoder = LabelEncoder()
veh['class_dup'] = labelencoder.fit_transform(veh['class'])
veh
Out[8]:
In the above step, The class was a categorical column. \ This can't be used in SVM algorithms. Thus the columns elements were given number. \ Such as bus is 0, Van is 2 and car is 1.
In [9]:
veh.mean()
Out[9]:
In [10]:
veh.drop("class",axis=1,inplace=True)
In [11]:
meanFiller = lambda x: x.fillna(x.mean())
veh = veh.apply(meanFiller,axis=0)
In the above step null values were replaced with means values of there respective columns \ and the class clomn was dropped.
Univariate Analysis¶
In [12]:
sns.distplot(veh["compactness"])
Out[12]:
In [13]:
sns.distplot(veh["circularity"])
Out[13]:
In [14]:
sns.distplot(veh["distance_circularity"])
Out[14]:
In [15]:
sns.distplot(veh["radius_ratio"])
Out[15]:
In [16]:
sns.distplot(veh["pr.axis_aspect_ratio"])
Out[16]:
In [17]:
sns.distplot(veh["max.length_aspect_ratio"])
Out[17]:
In [18]:
sns.distplot(veh["scatter_ratio"])
Out[18]:
In [19]:
sns.distplot(veh["elongatedness"])
Out[19]:
In [20]:
sns.distplot(veh["pr.axis_rectangularity"])
Out[20]:
In [21]:
sns.distplot(veh["scaled_variance"])
Out[21]:
In [22]:
sns.distplot(veh["scaled_variance.1"])
Out[22]:
In [23]:
sns.distplot(veh["scaled_radius_of_gyration"])
Out[23]:
In [24]:
sns.distplot(veh["scaled_radius_of_gyration.1"])
Out[24]:
In [25]:
sns.distplot(veh["skewness_about"])
Out[25]:
In [26]:
sns.distplot(veh["skewness_about.1"])
Out[26]:
In [27]:
sns.distplot(veh["skewness_about.2"])
Out[27]:
In [28]:
sns.distplot(veh["hollows_ratio"])
Out[28]:
Bivariate Analysis¶
In [29]:
sns.pairplot(veh,hue='class_dup',diag_kind='kde')
Out[29]:
Correlation table¶
In [30]:
core=veh.corr()
veh.corr()
Out[30]:
Correlation Heatmap¶
In [31]:
plt.figure(figsize = (21,15))
sns.heatmap(core,annot=True)
Out[31]:
From the bivariate analysis, correlation table and correlation heatmap.\ The columns the is of least significance to target variable was found.
Preprocessing Data for analysis¶
In [32]:
veh.drop("compactness",axis=1,inplace=True)
veh.drop("distance_circularity",axis=1,inplace=True)
veh.drop("pr.axis_aspect_ratio",axis=1,inplace=True)
veh.drop("max.length_rectangularity",axis=1,inplace=True)
veh.drop("scatter_ratio",axis=1,inplace=True)
veh.drop("pr.axis_rectangularity",axis=1,inplace=True)
veh.drop("skewness_about.2",axis=1,inplace=True)
In [33]:
X= veh.drop(["class_dup"],axis=1,)
Y= veh[["class_dup"]]
In [34]:
XScaled = X.apply(zscore)
Splitting the data into test,train¶
In [35]:
x_train, x_test, y_train, y_test = train_test_split(XScaled, Y, test_size=0.3, random_state=7)
SVM Analysis¶
In [36]:
clf = SVC(C= .1, kernel='linear', gamma= 1)
In [37]:
clf.fit(x_train , y_train.values.ravel())
Out[37]:
In [38]:
y_pred = clf.predict(x_test)
In [39]:
print("Accuracy:",accuracy_score(y_test, y_pred))
In [40]:
clf = SVC(C= .1, kernel='rbf', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
Out[40]:
In [41]:
y_pred = clf.predict(x_test)
In [42]:
print("Accuracy:",accuracy_score(y_test, y_pred))
In [43]:
clf = SVC(C= .1, kernel='poly', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
Out[43]:
In [44]:
y_pred = clf.predict(x_test)
print("Accuracy:",accuracy_score(y_test, y_pred))
In [45]:
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
In [46]:
knnm=metrics.confusion_matrix(y_test,y_pred)
knn_m = pd.DataFrame(knnm, index = [i for i in ["2","1","0"]],columns = [i for i in ["Predict 2","Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[46]:
In [47]:
print("Classification Report")
print(metrics.classification_report(y_test,y_pred, labels=[2,1, 0]))
In [48]:
clf = SVC(C= .1, kernel='sigmoid', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
Out[48]:
In [49]:
y_pred = clf.predict(x_test)
print("Accuracy:",accuracy_score(y_test, y_pred))
After trying the SVM algorithm in the different kernels. Following inference was made:-
- The highest model accuracy is when the algorithm is running in a polynomial kernel.
- The highest accuracy score was 91.
- Confusion matrix and classification reports were found for the same.
K-fold and cross-validation¶
In [50]:
kfold = KFold(n_splits=10, random_state=7,shuffle=True)
clf= SVC(C= .1, kernel='poly', gamma= 1)
model=clf.fit(x_train , y_train.values.ravel())
results = cross_val_score(model, XScaled, Y.values.ravel() , cv=kfold)
print(results)
print("Accuracy: %.3f%% (%.3f%%)" % (results.mean()*100.0, results.std()*100.0))
After using K-fold validation.
- The range of accuracy of the model was from 86% to 94% at a 95% confidence level.
Identifying Eigen vectors using PCA¶
In [51]:
covMatrix = np.cov(XScaled,rowvar=False)
print(covMatrix)
In [52]:
pca = PCA(n_components=6)
pca.fit(XScaled)
Out[52]:
In [53]:
print(pca.explained_variance_)
In [54]:
plt.bar(list(range(1,7)),pca.explained_variance_ratio_,alpha=0.5, align='center')
plt.ylabel('Variation explained')
plt.xlabel('eigen Value')
plt.show()
In [55]:
pca3 = PCA(n_components=6)
pca3.fit(XScaled)
print(pca3.components_)
print(pca3.explained_variance_ratio_)
Xpca3 = pca3.transform(XScaled)
In [56]:
Xpca3
Out[56]:
In [57]:
Xpca3.shape
Out[57]:
In [58]:
sns.pairplot(pd.DataFrame(Xpca3))
Out[58]:
In [59]:
x_train, x_test, y_train, y_test = train_test_split(Xpca3, Y, test_size=0.3, random_state=7)
SVM Analysis using the eigen vectors¶
In [60]:
clf = SVC(C= .1, kernel='linear', gamma= 1)
In [61]:
clf.fit(x_train , y_train.values.ravel())
Out[61]:
In [62]:
y_pred = clf.predict(x_test)
In [63]:
print("Accuracy:",accuracy_score(y_test, y_pred))
In [64]:
clf = SVC(C= .1, kernel='rbf', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
y_pred = clf.predict(x_test)
print("Accuracy:",accuracy_score(y_test, y_pred))
In [65]:
clf = SVC(C= .1, kernel='poly', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
y_pred = clf.predict(x_test)
print("Accuracy:",accuracy_score(y_test, y_pred))
In [66]:
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
In [67]:
knnm=metrics.confusion_matrix(y_test,y_pred)
knn_m = pd.DataFrame(knnm, index = [i for i in ["2","1","0"]],columns = [i for i in ["Predict2","Predict 1","Predict 0"]])
plt.figure(figsize = (7,5))
sns.heatmap(knn_m, annot=True)
Out[67]:
In [68]:
print("Classification Report")
print(metrics.classification_report(y_test,y_pred, labels=[2,1, 0]))
In [69]:
clf = SVC(C= .1, kernel='sigmoid', gamma= 1)
clf.fit(x_train , y_train.values.ravel())
y_pred = clf.predict(x_test)
print("Accuracy:",accuracy_score(y_test, y_pred))
After running the SVM model with eigenvectors in different kernels. The following was inferred.
- The maximum accuracy was again found in the polynomial kernel.
- The accuracy of this model was 83.
- A drop of around 6% was found but this expected as the columns are reduced
K-fold validadtion with PCA value¶
In [70]:
kfold = KFold(n_splits=10, random_state=7,shuffle=True)
clf= SVC(C= .1, kernel='poly', gamma= 1)
model=clf.fit(x_train , y_train.values.ravel())
results = cross_val_score(model, Xpca3, Y.values.ravel() , cv=kfold)
print(results)
print("Accuracy: %.3f%% (%.3f%%)" % (results.mean()*100.0, results.std()*100.0))
After using K-fold validation with eigen vectors.
- The range of accuracy of the model was from 80% to 87% at 95% confidence level.
Even after only selecting six column that covered 95% of data using PCA.
- The accuracy dropped from 91 to 83
- This is result was within the expected region.